Method: Dokumentenklasse(ClassObjectMap, LocalDateTime)

1: package auftraege;
2:
3: import auftraege.auftragsBildungsParameter.abstraction.DokumentenklassenVariable;
4: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.BlattAnzahl;
5: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.Id;
6: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.ProzessModell;
7: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.SendungsAnzahl;
8: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.UnbekannteVariable;
9: import auftraege.auftragsBildungsParameter.dokumentenKlassenVariablen.UnbekannteVariablen;
10: import util.ClassObjectMap;
11: import util.Constants;
12: import util.Immutable;
13:
14: import java.time.LocalDateTime;
15: import java.util.Arrays;
16: import java.util.List;
17: import java.util.Map;
18: import java.util.NoSuchElementException;
19: import java.util.Optional;
20: import java.util.stream.Collectors;
21:
22: /**
23: * Die Dokumentenklasse bildet das zentrale Element der Auftragsverwaltung. Hier werden entsprechende Regelwerke hinterlegt um die einzelnen Kundenaufträge und Dokumente
24: * in Dokumentenklassen zu gruppieren. Ziel dieser Gruppierung soll es sein, Auslastung von Maschinen zu steigern und die Ausnutzung von eingespannten Rollen zu
25: * verbessern. Dokumentenklassen entstehen durch die Kreuzung aller möglichen Kombinationen an Eigenschaften. Dies ermöglicht, dass jedes Dokument gemäß seinen
26: * Eigenschaften in genau eine Dokumentenklasse eingeordnet werden kann. Andersherum haben alle Dokumente innerhalb einer Dokumentenklasse genau identischen
27: * Rahmeneigenschaften. Diese äußerst genaue Unterteilung der Dokumentenklassen ermöglicht im späteren Produktionsverlauf
28: * eine präzise Produktionssteuerung vom Druck über das Kuvertieren bis zur Versandabfertigung.
29: */
30:
31: @Immutable
32: public class Dokumentenklasse {
33:
34:         private final ClassObjectMap<DokumentenklassenVariable> variablen;
35:         /**
36:          * Eingangszeitpunkt der Dokumentenklasse. Dieser entspricht dem Zeitpunkt, in dem die Dokumentenklasse im System registriert wurde.
37:          */
38:         private final LocalDateTime eingangsZeitpunkt;
39:
40:         /**
41:          * Erstellt eine Dokumentenklasse auf Basis von bereits existierenden DokumentenklassenVariablen. Hierbei werden ggf. unbekannte Variablen herausgefiltert und in eine
42:          * Liste von unbekannten Variablen eingefügt.
43:          *
44:          * @param variablen übergebene Variablen
45:          * @param eingangsZeitpunkt der Eingangszeitpunk, zu dem die Dokumentenklasse eingegangen ist.
46:          */
47:         public Dokumentenklasse(final List<Variable> variablen, final LocalDateTime eingangsZeitpunkt) {
48:                 this.variablen = new ClassObjectMap<>();
49:                 final Map<Boolean, List<DokumentenklassenVariable>> variablenMapInBeUndUnbekanntGeteilt = variablen.stream()
50:                                 .filter(variable -> !variable.getWert().equals(""))
51:                                 .map(variable -> DokumentenklassenVariable.create(variable.getBezeichung(), variable.getWert()))
52:                                 .collect(Collectors.partitioningBy(UnbekannteVariable.class::isInstance));
53:
54:                 final List<DokumentenklassenVariable> unbekannte = variablenMapInBeUndUnbekanntGeteilt.get(Boolean.TRUE);
55:                 if (!unbekannte.isEmpty()) {
56:                         this.variablen.put(new UnbekannteVariablen(unbekannte.stream()
57:                                         .map(UnbekannteVariable.class::cast)
58:                                         .collect(Collectors.toList())));
59:                 }
60:                 variablenMapInBeUndUnbekanntGeteilt.get(Boolean.FALSE).forEach(this.variablen::put);
61:
62:                 this.eingangsZeitpunkt = eingangsZeitpunkt;
63:         }
64:
65:         /**
66:          * Erstellt eine Dokumentenklasse auf Basis von bereits existierenden DokumentenklassenVariablen.
67:          *
68:          * @param variablen übergebene Variablen
69:          * @param eingangsZeitpunkt der Eingangszeitpunk, zu dem die Dokumentenklasse eingegangen ist.
70:          */
71:         public Dokumentenklasse(final ClassObjectMap<DokumentenklassenVariable> variablen, final LocalDateTime eingangsZeitpunkt) {
72:                 this.variablen = variablen;
73:                 this.eingangsZeitpunkt = eingangsZeitpunkt;
74:         }
75:
76:         /**
77:          * @param eingangsZeitpunkt
78:          *                 Eingangszeitpunkt der Dokumentenklasse.
79:          * @param variablen
80:          *                 DokumentenklassenVariablen, die in der Dokumentenklasse enthalten sein sollen.
81:          *
82:          * @return erstellt eine Dokumentenklasse auf Basis der übergebenen Variablen und dem Eingangszeitpunkt.
83:          */
84:         public static Dokumentenklasse create(final LocalDateTime eingangsZeitpunkt, final DokumentenklassenVariable... variablen) {
85:                 final ClassObjectMap<DokumentenklassenVariable> classObjectMap = new ClassObjectMap<>();
86:                 Arrays.stream(variablen).forEach(classObjectMap::put);
87:                 return new Dokumentenklasse(classObjectMap, eingangsZeitpunkt);
88:         }
89:
90:         /**
91:          * Diese Funktion gibt die Anzahl der Blätter zurück.
92:          *
93:          * @return die Anzahl der Blätter (0 falls nicht vorhanden)
94:          */
95:         public int getAnzahlBlaetter() {
96:                 final Optional<BlattAnzahl> blattAnzahl = this.variablen.get(BlattAnzahl.class);
97:                 return blattAnzahl.map(BlattAnzahl::intValue).orElse(0); // lässt vermuten, dass die Variable vielleicht vorhanden ist, obwohl das nicht der fall ist..
98:         }
99:
100:         /**
101:          * Diese Funktion gibt die Anzahl der Sendungen zurück.
102:          *
103:          * @return die Anzahl der Sendungen (0 falls nicht vorhanden)
104:          */
105:         public int getAnzahlSendungen() {
106:                 return this.variablen.get(SendungsAnzahl.class).map(SendungsAnzahl::getSendungsAnzahl).orElse(0);
107:         }
108:
109:         /**
110:          * Diese Funktion gibt den SLA zurück.
111:          *
112:          * @return den vorgegebenen SLA, oder einen maximalen Zeitpunkt, abhängig von der Ortszeit.
113:          */
114:         public ServiceLevelAgreement getSla() {
115:                 return this.variablen.get(ServiceLevelAgreement.class).orElse(ServiceLevelAgreement.MAX_VALUE);
116:         }
117:
118:         /**
119:          * Diese Funktion gibt das Prozessmodell zurück.
120:          *
121:          * @return Das zugehörige Prozessmodell oder wirft eine Exception, falls diese nicht vorhanden ist.
122:          */
123:         public ProzessModell getProzessModell() {
124:                 return this.variablen.get(ProzessModell.class)
125:                                 .orElseThrow(NoSuchElementException::new);
126:         }
127:
128:         /**
129:          * @return die {@link DokumentenklassenVariable} Id der {@link Dokumentenklasse} als Optional, da sie vielleicht gar nicht existiert
130:          */
131:         public Optional<Integer> getId() {
132:                 return this.variablen.get(Id.class).map(Id::getId);
133:         }
134:
135:         /**
136:          * @return sämtliche {@link DokumentenklassenVariable}n der {@link Dokumentenklasse} in Form einer {@link ClassObjectMap}
137:          */
138:         public ClassObjectMap<DokumentenklassenVariable> getVariablen() {
139:                 return this.variablen;
140:         }
141:
142:         /**
143:          * Liefert ein {@link Optional} der Klasse T.
144:          *
145:          * @param clazz Klasse, zu welcher ein Objekt aus dem DokumentenklassenBuilder geholt werden soll.
146:          * @param <T> extends {@link DokumentenklassenVariable}
147:          * @return Optional, welches ein Objekt der Klasse {@code clazz} enthalten kann.
148:          */
149:         <T extends DokumentenklassenVariable> Optional<T> getVariable(final Class<T> clazz) {
150:                 return this.variablen.get(clazz);
151:         }
152:
153:         @Override
154:         public boolean equals(final Object o) {
155:                 if (this == o) {
156:                         return true;
157:                 }
158:                 if (!(o instanceof Dokumentenklasse)) {
159:                         return false;
160:                 }
161:
162:                 final Dokumentenklasse that = (Dokumentenklasse) o;
163:
164:                 if (!this.variablen.equals(that.variablen)) {
165:                         return false;
166:                 }
167:                 return this.eingangsZeitpunkt.equals(that.eingangsZeitpunkt);
168:         }
169:
170:         @Override
171:         public int hashCode() {
172:                 int result = this.variablen.hashCode();
173:                 result = Constants.EINUNDDREISSIG * result + this.eingangsZeitpunkt.hashCode();
174:                 return result;
175:         }
176:
177:         @Override
178:         public String toString() {
179:                 return "Dokumentenklasse{" + this.eingangsZeitpunkt + " " + this.variablen.get(Id.class).map(Object::toString).orElse(this.variablen.toString()) + '}';
180:         }
181:
182:         /**
183:          * @return liefert den {@link Dokumentenklasse#eingangsZeitpunkt Eingangszeitpunkt} der Dokumentenklasse.
184:          */
185:         public LocalDateTime getEingangsZeitpunkt() {
186:                 return this.eingangsZeitpunkt;
187:         }
188:
189:         /**
190:          * @return liefert die Frist der Dokumentenklasse basierend auf dem {@link Dokumentenklasse#eingangsZeitpunkt Eingangszeitpunkt} und dem {@link ServiceLevelAgreement}
191:          */
192:         public LocalDateTime getFrist() {
193:                 return this.getSla().getFrist(this);
194:         }
195: }